package solutiondemo;

/**
 * Created with IntelliJ IDEA.
 * Description:
 * User: 黎鹤舞
 * Date: 2024-01-20
 * Time: 22:53
 */

class MyCircularQueue {

    private int[] elem;
    private int front;
    private int rear;
    private int capacity;

    //构造器
    public MyCircularQueue(int k) {
        this.capacity = k + 1;
        this.elem = new int[capacity];
        this.front = 0;
        this.rear = 0;
    }

    //插入元素，插入成功返回真
    public boolean enQueue(int value) {
        if(isFull()) {
            return false;
        }
        this.elem[rear] = value;
        this.rear = (rear + 1) % capacity;
        return true;
    }


    //删除元素，删除成功返回真
    public boolean deQueue() {
        if(isEmpty()) {
            return false;
        }
        this.front = (front + 1) % capacity;
        return true;
    }


    //从队首获取元素,如果队列为空返回-1
    public int Front() {
        if(isEmpty()) {
            return -1;
        }
        return elem[front];
    }

    //从队尾获取元素，如果队列为空返回-1
    public int Rear() {
        if(isEmpty()) {
            return -1;
        }
        //这里特别注意:
        // -1操作时，有可能出现front在首位的情况，如果只是普通的-1会直接到复数；
        // 想要其相对位置保持不变，必须要 + capacity,跳过一整个，但是涉及到+就会导致属于移除，需要 % capacity
        return elem[(rear - 1 + capacity) % capacity];
    }


    //判断队列是否为空
    public boolean isEmpty() {
        return this.front == this.rear;
    }


    //判断队列是否已满
    public boolean isFull() {
        return (rear + 1) % this.capacity == this.front;
    }
}



//public class MyCircularQueue {
//
//    private int front;
//    private int rear;
//    private int capacity;
//    private int[] arr;
//
//    /**
//     * Initialize your data structure here. Set the size of the queue to be k.
//     */
//    public MyCircularQueue(int k) {
//        capacity = k + 1;
//        arr = new int[capacity];
//
//        // 在 front 出队，故设计在数组的头部，方便删除元素
//        // 删除元素的时候，只索引 +1（注意取模）
//
//
//        // 在 rear 入队，故设计在数组的尾部，方便插入元素
//        // 插入元素的时候，先赋值，后索引 +1（注意取模）
//        front = 0;
//        rear = 0;
//    }
//
//    /**
//     * Insert an element into the circular queue. Return true if the operation is successful.
//     */
//    public boolean enQueue(int value) {
//        if (isFull()) {
//            return false;
//        }
//        arr[rear] = value;
//        rear = (rear + 1) % capacity;
//        return true;
//    }
//
//    /**
//     * Delete an element from the circular queue. Return true if the operation is successful.
//     */
//    public boolean deQueue() {
//        if (isEmpty()) {
//            return false;
//        }
//        front = (front + 1) % capacity;
//        return true;
//    }
//
//    /**
//     * Get the front item from the queue.
//     */
//    public int Front() {
//        if (isEmpty()) {
//            return -1;
//        }
//        return arr[front];
//    }
//
//    /**
//     * Get the last item from the queue.
//     */
//    public int Rear() {
//        if (isEmpty()) {
//            return -1;
//        }
//        return arr[(rear - 1 + capacity) % capacity];
//    }
//
//    /**
//     * Checks whether the circular queue is empty or not.
//     */
//    public boolean isEmpty() {
//        return front == rear;
//    }
//
//    /**
//     * Checks whether the circular queue is full or not.
//     */
//    public boolean isFull() {
//        // 注意：这是这个经典设计的原因:利用空余位置来区分栈空和栈满
//        return (rear + 1) % capacity == front;
//    }
//}
